home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / pyxmpp / roster.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  8.5 KB  |  322 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __revision__ = '$Id: roster.py 647 2006-08-26 18:27:39Z jajcus $'
  5. __docformat__ = 'restructuredtext en'
  6. import libxml2
  7. from pyxmpp.xmlextra import common_doc, get_node_ns_uri
  8. from pyxmpp.iq import Iq
  9. from pyxmpp.jid import JID
  10. from pyxmpp.utils import to_utf8, from_utf8
  11. from pyxmpp.objects import StanzaPayloadObject
  12. ROSTER_NS = 'jabber:iq:roster'
  13.  
  14. class RosterItem(StanzaPayloadObject):
  15.     xml_element_name = 'item'
  16.     xml_element_namespace = ROSTER_NS
  17.     
  18.     def __init__(self, node_or_jid, subscription = 'none', name = None, groups = (), ask = None):
  19.         if isinstance(node_or_jid, libxml2.xmlNode):
  20.             self.from_xml(node_or_jid)
  21.         else:
  22.             node_or_jid = JID(node_or_jid)
  23.             if subscription not in ('none', 'from', 'to', 'both', 'remove'):
  24.                 raise ValueError, 'Bad subscription type: %r' % (subscription,)
  25.             
  26.             if ask not in ('subscribe', None):
  27.                 raise ValueError, 'Bad ask type: %r' % (ask,)
  28.             
  29.             self.jid = node_or_jid
  30.             self.ask = ask
  31.             self.subscription = subscription
  32.             self.name = name
  33.             self.groups = list(groups)
  34.  
  35.     
  36.     def from_xml(self, node):
  37.         if node.type != 'element':
  38.             raise ValueError, 'XML node is not a roster item (not en element)'
  39.         
  40.         ns = get_node_ns_uri(node)
  41.         if ns or ns != ROSTER_NS or node.name != 'item':
  42.             raise ValueError, 'XML node is not a roster item'
  43.         
  44.         jid = JID(node.prop('jid').decode('utf-8'))
  45.         subscription = node.prop('subscription')
  46.         if subscription not in ('none', 'from', 'to', 'both', 'remove'):
  47.             subscription = 'none'
  48.         
  49.         ask = node.prop('ask')
  50.         if ask not in ('subscribe', None):
  51.             ask = None
  52.         
  53.         name = from_utf8(node.prop('name'))
  54.         groups = []
  55.         n = node.children
  56.         while n:
  57.             if n.type != 'element':
  58.                 n = n.next
  59.                 continue
  60.             
  61.             ns = get_node_ns_uri(n)
  62.             if ns or ns != ROSTER_NS or n.name != 'group':
  63.                 n = n.next
  64.                 continue
  65.             
  66.             group = n.getContent()
  67.             if group:
  68.                 groups.append(from_utf8(group))
  69.             
  70.             n = n.next
  71.         self.jid = jid
  72.         self.name = name
  73.         self.groups = groups
  74.         self.subscription = subscription
  75.         self.ask = ask
  76.  
  77.     
  78.     def complete_xml_element(self, xmlnode, _unused):
  79.         xmlnode.setProp('jid', self.jid.as_utf8())
  80.         if self.name:
  81.             xmlnode.setProp('name', to_utf8(self.name))
  82.         
  83.         xmlnode.setProp('subscription', self.subscription)
  84.         if self.ask:
  85.             xmlnode.setProp('ask', to_utf8(self.ask))
  86.         
  87.         for g in self.groups:
  88.             xmlnode.newTextChild(None, 'group', to_utf8(g))
  89.         
  90.  
  91.     
  92.     def __str__(self):
  93.         n = self.as_xml(doc = common_doc)
  94.         r = n.serialize()
  95.         n.unlinkNode()
  96.         n.freeNode()
  97.         return r
  98.  
  99.     
  100.     def make_roster_push(self):
  101.         iq = Iq(stanza_type = 'set')
  102.         q = iq.new_query(ROSTER_NS)
  103.         self.as_xml(parent = q, doc = common_doc)
  104.         return iq
  105.  
  106.  
  107.  
  108. class Roster(StanzaPayloadObject):
  109.     xml_element_name = 'query'
  110.     xml_element_namespace = ROSTER_NS
  111.     
  112.     def __init__(self, node = None, server = False, strict = True):
  113.         self.items_dict = { }
  114.         self.server = server
  115.         self.node = None
  116.         if node:
  117.             self.from_xml(node, strict)
  118.         
  119.  
  120.     
  121.     def from_xml(self, node, strict = True):
  122.         self.items_dict = { }
  123.         if node.type != 'element':
  124.             raise ValueError, 'XML node is not a roster (not en element)'
  125.         
  126.         ns = get_node_ns_uri(node)
  127.         if ns or ns != ROSTER_NS or node.name != 'query':
  128.             raise ValueError, 'XML node is not a roster'
  129.         
  130.         n = node.children
  131.         while n:
  132.             if n.type != 'element':
  133.                 n = n.next
  134.                 continue
  135.             
  136.             ns = get_node_ns_uri(n)
  137.             if ns or ns != ROSTER_NS or n.name != 'item':
  138.                 n = n.next
  139.                 continue
  140.             
  141.             
  142.             try:
  143.                 item = RosterItem(n)
  144.                 self.items_dict[item.jid] = item
  145.             except ValueError:
  146.                 if strict:
  147.                     raise 
  148.                 
  149.             except:
  150.                 strict
  151.  
  152.             n = n.next
  153.  
  154.     
  155.     def complete_xml_element(self, xmlnode, doc):
  156.         for it in self.items_dict.values():
  157.             it.as_xml(parent = xmlnode, doc = doc)
  158.         
  159.  
  160.     
  161.     def __str__(self):
  162.         n = self.as_xml(doc = common_doc)
  163.         r = n.serialize()
  164.         n.unlinkNode()
  165.         n.freeNode()
  166.         return r
  167.  
  168.     
  169.     def __iter__(self):
  170.         return self.items_dict.itervalues()
  171.  
  172.     
  173.     def __contains__(self, jid):
  174.         return jid in self.items_dict
  175.  
  176.     
  177.     def __getitem__(self, jid):
  178.         return self.items_dict[jid]
  179.  
  180.     
  181.     def get_items(self):
  182.         return self.items_dict.values()
  183.  
  184.     items = property(get_items)
  185.     
  186.     def get_groups(self):
  187.         r = { }
  188.         for it in self.items_dict.values():
  189.             it.groups = _[1]
  190.             if it.groups:
  191.                 for g in it.groups:
  192.                     r[g] = True
  193.                 
  194.             []
  195.             r[None] = True
  196.         
  197.         return r.keys()
  198.  
  199.     
  200.     def get_items_by_name(self, name, case_sensitive = True):
  201.         if not case_sensitive and name:
  202.             name = name.lower()
  203.         
  204.         r = []
  205.         for it in self.items_dict.values():
  206.             if it.name == name:
  207.                 r.append(it)
  208.                 continue
  209.             if it.name is None:
  210.                 continue
  211.                 continue
  212.             if not case_sensitive and it.name.lower() == name:
  213.                 r.append(it)
  214.                 continue
  215.         
  216.         return r
  217.  
  218.     
  219.     def get_items_by_group(self, group, case_sensitive = True):
  220.         r = []
  221.         if not group:
  222.             for it in self.items_dict.values():
  223.                 it.groups = _[1]
  224.                 if not it.groups:
  225.                     r.append(it)
  226.                     continue
  227.                 []
  228.             
  229.             return r
  230.         
  231.         if not case_sensitive:
  232.             group = group.lower()
  233.         
  234.         for it in self.items_dict.values():
  235.             if group in it.groups:
  236.                 r.append(it)
  237.                 continue
  238.             if not case_sensitive and [] in [ g.lower() for g in it.groups ]:
  239.                 r.append(it)
  240.                 continue
  241.             []
  242.         
  243.         return r
  244.  
  245.     
  246.     def get_item_by_jid(self, jid):
  247.         if not jid:
  248.             raise ValueError, 'jid is None'
  249.         
  250.         return self.items_dict[jid]
  251.  
  252.     
  253.     def add_item(self, item_or_jid, subscription = 'none', name = None, groups = (), ask = None):
  254.         if isinstance(item_or_jid, RosterItem):
  255.             item = item_or_jid
  256.             if self.items_dict.has_key(item.jid):
  257.                 raise ValueError, 'Item already exists'
  258.             
  259.         elif self.items_dict.has_key(item_or_jid):
  260.             raise ValueError, 'Item already exists'
  261.         
  262.         if not (self.server) or subscription not in ('none', 'from', 'to', 'both'):
  263.             subscription = 'none'
  264.         
  265.         if not self.server:
  266.             ask = None
  267.         
  268.         item = RosterItem(item_or_jid, subscription, name, groups, ask)
  269.         self.items_dict[item.jid] = item
  270.         return item
  271.  
  272.     
  273.     def remove_item(self, jid):
  274.         del self.items_dict[jid]
  275.         return RosterItem(jid, 'remove')
  276.  
  277.     
  278.     def update(self, query):
  279.         ctxt = common_doc.xpathNewContext()
  280.         ctxt.setContextNode(query)
  281.         ctxt.xpathRegisterNs('r', ROSTER_NS)
  282.         items = ctxt.xpathEval('r:item')
  283.         ctxt.xpathFreeContext()
  284.         if not items:
  285.             raise ValueError, 'No item to update'
  286.         
  287.         local_items = []
  288.         for item in items:
  289.             item = RosterItem(item)
  290.             jid = item.jid
  291.             subscription = item.subscription
  292.             
  293.             try:
  294.                 local_item = self.get_item_by_jid(jid)
  295.                 local_item.subscription = subscription
  296.             except KeyError:
  297.                 if subscription == 'remove':
  298.                     return [
  299.                         RosterItem(jid, 'remove')]
  300.                 
  301.                 if self.server or subscription not in ('none', 'from', 'to', 'both'):
  302.                     subscription = 'none'
  303.                 
  304.                 local_item = RosterItem(jid, subscription)
  305.  
  306.             if subscription == 'remove':
  307.                 del self.items_dict[local_item.jid]
  308.                 return [
  309.                     RosterItem(jid, 'remove')]
  310.             
  311.             local_item.name = item.name
  312.             local_item.groups = list(item.groups)
  313.             if not self.server:
  314.                 local_item.ask = item.ask
  315.             
  316.             self.items_dict[local_item.jid] = local_item
  317.             local_items.append(local_item)
  318.         
  319.         return local_items
  320.  
  321.  
  322.